home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / nfsd / state.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  10.8 KB  |  309 lines
  1. /*
  2.  *  linux/include/nfsd/state.h
  3.  *
  4.  *  Copyright (c) 2001 The Regents of the University of Michigan.
  5.  *  All rights reserved.
  6.  *
  7.  *  Kendrick Smith <kmsmith@umich.edu>
  8.  *  Andy Adamson <andros@umich.edu>
  9.  *  
  10.  *  Redistribution and use in source and binary forms, with or without
  11.  *  modification, are permitted provided that the following conditions
  12.  *  are met:
  13.  *  
  14.  *  1. Redistributions of source code must retain the above copyright
  15.  *     notice, this list of conditions and the following disclaimer.
  16.  *  2. Redistributions in binary form must reproduce the above copyright
  17.  *     notice, this list of conditions and the following disclaimer in the
  18.  *     documentation and/or other materials provided with the distribution.
  19.  *  3. Neither the name of the University nor the names of its
  20.  *     contributors may be used to endorse or promote products derived
  21.  *     from this software without specific prior written permission.
  22.  *
  23.  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  24.  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25.  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26.  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27.  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28.  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29.  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  30.  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31.  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32.  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33.  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34.  *
  35.  */
  36.  
  37. #ifndef _NFSD4_STATE_H
  38. #define _NFSD4_STATE_H
  39.  
  40. #include <linux/list.h>
  41. #include <linux/kref.h>
  42. #include <linux/sunrpc/clnt.h>
  43.  
  44. #define NFS4_OPAQUE_LIMIT 1024
  45. typedef struct {
  46.     u32             cl_boot;
  47.     u32             cl_id;
  48. } clientid_t;
  49.  
  50. typedef struct {
  51.     u32             so_boot;
  52.     u32             so_stateownerid;
  53.     u32             so_fileid;
  54. } stateid_opaque_t;
  55.  
  56. typedef struct {
  57.     u32                     si_generation;
  58.     stateid_opaque_t        si_opaque;
  59. } stateid_t;
  60. #define si_boot           si_opaque.so_boot
  61. #define si_stateownerid   si_opaque.so_stateownerid
  62. #define si_fileid         si_opaque.so_fileid
  63.  
  64.  
  65. struct nfs4_cb_recall {
  66.     u32            cbr_ident;
  67.     int            cbr_trunc;
  68.     stateid_t        cbr_stateid;
  69.     u32            cbr_fhlen;
  70.     char            cbr_fhval[NFS4_FHSIZE];
  71.     struct nfs4_delegation    *cbr_dp;
  72. };
  73.  
  74. struct nfs4_delegation {
  75.     struct list_head    dl_perfile;
  76.     struct list_head    dl_perclnt;
  77.     struct list_head    dl_recall_lru;  /* delegation recalled */
  78.     atomic_t        dl_count;       /* ref count */
  79.     struct nfs4_client    *dl_client;
  80.     struct nfs4_file    *dl_file;
  81.     struct file_lock    *dl_flock;
  82.     struct file        *dl_vfs_file;
  83.     u32            dl_type;
  84.     time_t            dl_time;
  85.     struct nfs4_cb_recall    dl_recall;
  86. };
  87.  
  88. #define dl_stateid      dl_recall.cbr_stateid
  89. #define dl_fhlen        dl_recall.cbr_fhlen
  90. #define dl_fhval        dl_recall.cbr_fhval
  91.  
  92. /* client delegation callback info */
  93. struct nfs4_callback {
  94.     /* SETCLIENTID info */
  95.     u32                     cb_addr;
  96.     unsigned short          cb_port;
  97.     u32                     cb_prog;
  98.     u32                     cb_ident;
  99.     /* RPC client info */
  100.     atomic_t        cb_set;     /* successful CB_NULL call */
  101.     struct rpc_clnt *       cb_client;
  102. };
  103.  
  104. #define HEXDIR_LEN     33 /* hex version of 16 byte md5 of cl_name plus '\0' */
  105.  
  106. /*
  107.  * struct nfs4_client - one per client.  Clientids live here.
  108.  *     o Each nfs4_client is hashed by clientid.
  109.  *
  110.  *     o Each nfs4_clients is also hashed by name 
  111.  *       (the opaque quantity initially sent by the client to identify itself).
  112.  *       
  113.  *    o cl_perclient list is used to ensure no dangling stateowner references
  114.  *      when we expire the nfs4_client
  115.  */
  116. struct nfs4_client {
  117.     struct list_head    cl_idhash;     /* hash by cl_clientid.id */
  118.     struct list_head    cl_strhash;     /* hash by cl_name */
  119.     struct list_head    cl_openowners;
  120.     struct list_head    cl_delegations;
  121.     struct list_head        cl_lru;         /* tail queue */
  122.     struct xdr_netobj    cl_name;     /* id generated by client */
  123.     char                    cl_recdir[HEXDIR_LEN]; /* recovery dir */
  124.     nfs4_verifier        cl_verifier;     /* generated by client */
  125.     time_t                  cl_time;        /* time of last lease renewal */
  126.     __be32            cl_addr;     /* client ipaddress */
  127.     struct svc_cred        cl_cred;     /* setclientid principal */
  128.     clientid_t        cl_clientid;    /* generated by server */
  129.     nfs4_verifier        cl_confirm;    /* generated by server */
  130.     struct nfs4_callback    cl_callback;    /* callback info */
  131.     atomic_t        cl_count;    /* ref count */
  132.     u32            cl_firststate;    /* recovery dir creation */
  133. };
  134.  
  135. /* struct nfs4_client_reset
  136.  * one per old client. Populates reset_str_hashtbl. Filled from conf_id_hashtbl
  137.  * upon lease reset, or from upcall to state_daemon (to read in state
  138.  * from non-volitile storage) upon reboot.
  139.  */
  140. struct nfs4_client_reclaim {
  141.     struct list_head    cr_strhash;    /* hash by cr_name */
  142.     char            cr_recdir[HEXDIR_LEN]; /* recover dir */
  143. };
  144.  
  145. static inline void
  146. update_stateid(stateid_t *stateid)
  147. {
  148.     stateid->si_generation++;
  149. }
  150.  
  151. /* A reasonable value for REPLAY_ISIZE was estimated as follows:  
  152.  * The OPEN response, typically the largest, requires 
  153.  *   4(status) + 8(stateid) + 20(changeinfo) + 4(rflags) +  8(verifier) + 
  154.  *   4(deleg. type) + 8(deleg. stateid) + 4(deleg. recall flag) + 
  155.  *   20(deleg. space limit) + ~32(deleg. ace) = 112 bytes 
  156.  */
  157.  
  158. #define NFSD4_REPLAY_ISIZE       112 
  159.  
  160. /*
  161.  * Replay buffer, where the result of the last seqid-mutating operation 
  162.  * is cached. 
  163.  */
  164. struct nfs4_replay {
  165.     __be32            rp_status;
  166.     unsigned int        rp_buflen;
  167.     char            *rp_buf;
  168.     unsigned        intrp_allocated;
  169.     int            rp_openfh_len;
  170.     char            rp_openfh[NFS4_FHSIZE];
  171.     char            rp_ibuf[NFSD4_REPLAY_ISIZE];
  172. };
  173.  
  174. /*
  175. * nfs4_stateowner can either be an open_owner, or a lock_owner
  176. *
  177. *    so_idhash:  stateid_hashtbl[] for open owner, lockstateid_hashtbl[]
  178. *         for lock_owner
  179. *    so_strhash: ownerstr_hashtbl[] for open_owner, lock_ownerstr_hashtbl[]
  180. *         for lock_owner
  181. *    so_perclient: nfs4_client->cl_perclient entry - used when nfs4_client
  182. *         struct is reaped.
  183. *    so_perfilestate: heads the list of nfs4_stateid (either open or lock) 
  184. *         and is used to ensure no dangling nfs4_stateid references when we 
  185. *         release a stateowner.
  186. *    so_perlockowner: (open) nfs4_stateid->st_perlockowner entry - used when
  187. *         close is called to reap associated byte-range locks
  188. *    so_close_lru: (open) stateowner is placed on this list instead of being
  189. *         reaped (when so_perfilestate is empty) to hold the last close replay.
  190. *         reaped by laundramat thread after lease period.
  191. */
  192. struct nfs4_stateowner {
  193.     struct kref        so_ref;
  194.     struct list_head        so_idhash;   /* hash by so_id */
  195.     struct list_head        so_strhash;   /* hash by op_name */
  196.     struct list_head        so_perclient;
  197.     struct list_head        so_stateids;
  198.     struct list_head        so_perstateid; /* for lockowners only */
  199.     struct list_head    so_close_lru; /* tail queue */
  200.     time_t            so_time; /* time of placement on so_close_lru */
  201.     int            so_is_open_owner; /* 1=openowner,0=lockowner */
  202.     u32                     so_id;
  203.     struct nfs4_client *    so_client;
  204.     /* after increment in ENCODE_SEQID_OP_TAIL, represents the next
  205.      * sequence id expected from the client: */
  206.     u32                     so_seqid;
  207.     struct xdr_netobj       so_owner;     /* open owner name */
  208.     int                     so_confirmed; /* successful OPEN_CONFIRM? */
  209.     struct nfs4_replay    so_replay;
  210. };
  211.  
  212. /*
  213. *  nfs4_file: a file opened by some number of (open) nfs4_stateowners.
  214. *    o fi_perfile list is used to search for conflicting 
  215. *      share_acces, share_deny on the file.
  216. */
  217. struct nfs4_file {
  218.     struct kref        fi_ref;
  219.     struct list_head        fi_hash;    /* hash by "struct inode *" */
  220.     struct list_head        fi_stateids;
  221.     struct list_head    fi_delegations;
  222.     struct inode        *fi_inode;
  223.     u32                     fi_id;      /* used with stateowner->so_id 
  224.                          * for stateid_hashtbl hash */
  225.     bool            fi_had_conflict;
  226. };
  227.  
  228. /*
  229. * nfs4_stateid can either be an open stateid or (eventually) a lock stateid
  230. *
  231. * (open)nfs4_stateid: one per (open)nfs4_stateowner, nfs4_file
  232. *
  233. *     st_hash: stateid_hashtbl[] entry or lockstateid_hashtbl entry
  234. *     st_perfile: file_hashtbl[] entry.
  235. *     st_perfile_state: nfs4_stateowner->so_perfilestate
  236. *       st_perlockowner: (open stateid) list of lock nfs4_stateowners
  237. *     st_access_bmap: used only for open stateid
  238. *     st_deny_bmap: used only for open stateid
  239. *    st_openstp: open stateid lock stateid was derived from
  240. *
  241. * XXX: open stateids and lock stateids have diverged sufficiently that
  242. * we should consider defining separate structs for the two cases.
  243. */
  244.  
  245. struct nfs4_stateid {
  246.     struct list_head              st_hash; 
  247.     struct list_head              st_perfile;
  248.     struct list_head              st_perstateowner;
  249.     struct list_head              st_lockowners;
  250.     struct nfs4_stateowner      * st_stateowner;
  251.     struct nfs4_file            * st_file;
  252.     stateid_t                     st_stateid;
  253.     struct file                 * st_vfs_file;
  254.     unsigned long                 st_access_bmap;
  255.     unsigned long                 st_deny_bmap;
  256.     struct nfs4_stateid         * st_openstp;
  257. };
  258.  
  259. /* flags for preprocess_seqid_op() */
  260. #define CHECK_FH                0x00000001
  261. #define CONFIRM                 0x00000002
  262. #define OPEN_STATE              0x00000004
  263. #define LOCK_STATE              0x00000008
  264. #define RD_STATE            0x00000010
  265. #define WR_STATE            0x00000020
  266. #define CLOSE_STATE             0x00000040
  267. #define DELEG_RET               0x00000080
  268.  
  269. #define seqid_mutating_err(err)                       \
  270.     (((err) != nfserr_stale_clientid) &&    \
  271.     ((err) != nfserr_bad_seqid) &&          \
  272.     ((err) != nfserr_stale_stateid) &&      \
  273.     ((err) != nfserr_bad_stateid))
  274.  
  275. extern __be32 nfs4_preprocess_stateid_op(struct svc_fh *current_fh,
  276.         stateid_t *stateid, int flags, struct file **filp);
  277. extern void nfs4_lock_state(void);
  278. extern void nfs4_unlock_state(void);
  279. extern int nfs4_in_grace(void);
  280. extern __be32 nfs4_check_open_reclaim(clientid_t *clid);
  281. extern void put_nfs4_client(struct nfs4_client *clp);
  282. extern void nfs4_free_stateowner(struct kref *kref);
  283. extern void nfsd4_probe_callback(struct nfs4_client *clp);
  284. extern void nfsd4_cb_recall(struct nfs4_delegation *dp);
  285. extern void nfs4_put_delegation(struct nfs4_delegation *dp);
  286. extern __be32 nfs4_make_rec_clidname(char *clidname, struct xdr_netobj *clname);
  287. extern void nfsd4_init_recdir(char *recdir_name);
  288. extern int nfsd4_recdir_load(void);
  289. extern void nfsd4_shutdown_recdir(void);
  290. extern int nfs4_client_to_reclaim(const char *name);
  291. extern int nfs4_has_reclaimed_state(const char *name);
  292. extern void nfsd4_recdir_purge_old(void);
  293. extern int nfsd4_create_clid_dir(struct nfs4_client *clp);
  294. extern void nfsd4_remove_clid_dir(struct nfs4_client *clp);
  295.  
  296. static inline void
  297. nfs4_put_stateowner(struct nfs4_stateowner *so)
  298. {
  299.     kref_put(&so->so_ref, nfs4_free_stateowner);
  300. }
  301.  
  302. static inline void
  303. nfs4_get_stateowner(struct nfs4_stateowner *so)
  304. {
  305.     kref_get(&so->so_ref);
  306. }
  307.  
  308. #endif   /* NFSD4_STATE_H */
  309.